/*
 * Copyright 2009 Al Phillips.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package xsd4gorm.xsd.parts

import xsd4gorm.model.DomainType
import xsd4gorm.model.DomainClass
import xsd4gorm.xsd.support.XSDPart
import xsd4gorm.xsd.support.XSDEdible
import xsd4gorm.xsd.support.XSDEdible

/**
 *
 * @author Al Phillips
 */
public class Element extends XSDPart implements XSDEdible {

    public void process(def node, def model){
        DomainType type = new DomainType()

        if(isUnbounded(node)){
            type.setHasMany(true)
        }

        XSDType xsdType = new XSDType(node.@type)

        if (xsdType.isXSDBuiltInType()){
            type.setName(node.@name.text())
            type.setType(xsdType.getXSDType())
                
        } else {
            if(hasAttribute(node.@type)){
                // TODO: can there be no name?
                if (node.@name.text() == ''){
                        throw new Exception('Where the hell is the name')
                }
                type.setName(node.@name.text())
                type.setType(node.@type.text())
                type.setUnresolved(true)
            } else {

                if (hasAttribute(node.@name)){
                    node.complexType.each {
                        type.setName(node.@name.text())
                        type.setType(DomainClass.makeNameClassFriendly(node.@name.text()))
                        type.setUnresolved(true)
                        new ComplexType(node.@name.text()).process(it, model)
                    }

                    node.simpleType.each {
                        new SimpleType(node.@name.text()).process(it, model)
                    }
                } else {
                        // TODO: ref
                }
            }
        }

        if(type.getType() && type.getName()){
            model.addType(type)
        }
    }

    private boolean isUnbounded(node){
        if(node.@maxOccurs.text() == "unbounded"){
            return true
        }
        false
    }

    private int getMaxOccurs(node){
        return 0
    }
}